package cz.pecinovsky.česky.oopnz._125_;
//Příliš žluťoučký kůň úpěl ďábelské ódy

import cz.pecinovsky.česky.oopnz._000_.Run;

import cz.pecinovsky.česky.oopnz.správce.Přesouvač;
import cz.pecinovsky.česky.oopnz.správce.SprávcePlátna;


import static cz.pecinovsky.česky.oopnz._125_.Semafor_125_133.Semafor;
import static cz.pecinovsky.česky.oopnz._125_.TestUtility_129_133.TestUtility;


////////////////////////////////////////////////////////////////////////////////
//%%+  +++++ Konec ignorovaného počátečního textu +++++
//%I+ =133c
//
//import správce.*;
//%I-
//%I+ >=133z
//
//import cz.pecinovsky.česky.oopnz.správceplátna.Přesouvač;
//import cz.pecinovsky.česky.oopnz.správceplátna.SprávcePlátna;
//%I-
//%A+ >=133z

import cz.pecinovsky.česky.oopnz.utility.Barva;
import cz.pecinovsky.česky.oopnz.utility.IO;
import cz.pecinovsky.česky.oopnz.utility.Pozice;
//%A-
//%X+ xxxxx Začátek přeskakovaného textu xxxxx
/*******************************************************************************
 *<pre>
 * Předchozí:   Není - toto_je_nově_definovaná_třída
 *              Ttt v projektu Ppp
 * Následující: Prozatím není
 *
 * Projekt  Ppp
 *   + Přidáno
 *   - Odebráno
 *   ~ Změněno
 *</pre>
 */
public class SemaforTest_125_133
{    private SemaforTest_125_133() {}   static
////////////////////////////////////////////////////////////////////////////////
//%X- ----- Konec přeskakovaného textu -----


/*******************************************************************************
 * Testovací třída {@code SemaforTest}  slouží ke komplexnímu otestování
 * třídy {@link SemaforTest}.
 *
 * @author Rudolf PECINOVSKÝ
 * @version 6.03.2017 — 2010-11-08
 */
public class SemaforTest extends junit.framework.TestCase
{
    private SprávcePlátna SP;
    private Semafor semafor0;
    private Semafor semaforXY;
    private Semafor semaforXYB;
    private Semafor semaforXYM;
    private Semafor semaforXYMB;



//== KONSTANTNÍ ATRIBUTY TŘÍDY =================================================
//== PROMĚNNÉ ATRIBUTY TŘÍDY ===================================================
//== STATICKÝ INICIALIZAČNÍ BLOK - STATICKÝ KONSTRUKTOR ========================
//== KONSTANTNÍ ATRIBUTY INSTANCÍ ==============================================
//== PROMĚNNÉ ATRIBUTY INSTANCÍ ================================================
//== PŘÍSTUPOVÉ METODY VLASTNOSTÍ TŘÍDY ========================================
//== OSTATNÍ NESOUKROMÉ METODY TŘÍDY ===========================================

//##############################################################################
//== KONSTRUKTORY A TOVÁRNÍ METODY =============================================

    /***************************************************************************
     * Vytvoří test se zadaným názvem.
     *
     * @param název  Název konstruovaného testu
     */
    public SemaforTest( String název )
    {
        super(název);
    }



//== PŘÍPRAVA A ÚKLID PŘÍPRAVKU ================================================

    /***************************************************************************
     * Inicializace předcházející spuštění každého testu a připravující tzv.
     * přípravek (fixture), což je sada objektů, s nimiž budou testy pracovat.
     */
    @Override
    protected void setUp()
    {
        semafor0   = new Semafor();
        semaforXY  = new Semafor(100,  50);
        semaforXYB = new Semafor(150, 100, Barva.HNĚDÁ);
        semaforXYM = new Semafor( 75,  25, 25);
        semaforXYMB= new Semafor(200,   0, 100, Barva.MODRÁ);

        SP = SprávcePlátna.getInstance();
        SP.přidej(semafor0);
        SP.přidej(semaforXY);
        SP.přidej(semaforXYB);
        SP.přidej(semaforXYM);
        SP.přidej(semaforXYMB);

//%X+ <126
        System.out.println("\n====== Instance v přípravku pro " + this +
                           "\n| SP: " + SP +
                           "\n| semafor0:    " + semafor0 +
                           "\n| semaforXY:   " + semaforXY +
                           "\n| semaforXYB:  " + semaforXYB +
                           "\n| semaforXYM : " + semaforXYM +
                           "\n| semaforXYMB: " + semaforXYMB +
                           "\n======");
//%X-
        IO.zpráva("Semafory připraveny");
    }


    /***************************************************************************
     * Úklid po testu - tato metoda se spustí po vykonání každého testu.
     */
    @Override
    protected void tearDown()
    {
    }


//== SOUKROMÉ A POMOCNÉ METODY TŘÍDY ===========================================
//== SOUKROMÉ A POMOCNÉ METODY INSTANCÍ ========================================
//%I+ <129
//
//    /***************************************************************************
//     * Za pomoci přesouvače plynule prohodí pozice zadaných semaforů.
//     *
//     * @param s1 První semafor
//     * @param s2 Druhý semafor
//     */
//    private void pomPlynuleProhoďPozice(Semafor s1, Semafor s2)
//    {
//        Přesouvač přesouvač = new Přesouvač(10);
//        Pozice p1 = s1.getPozice();
//        přesouvač.přesunNa(s2.getPozice(), s1);
//        přesouvač.přesunNa(p1,             s2);
//    }
//
//
//    /***************************************************************************
//     * Vyzkouší změny pozice a velikosti zadaného semaforu.
//     *
//     * @param s Testovaný semafor
//     */
//    private void pomPoziceVelikost(Semafor s)
//    {
//        final int ms = 500;
//        s.setPozice(50, 0);
//        IO.čekej(ms);
//        s.setModul(100);
//        IO.čekej(ms);
//        s.setModul(25);
//        IO.čekej(ms);
//        SP.odstraň(s);
//        IO.čekej(ms);
//    }
//
//%I-
//%I+ >127 <129
//
//    /***************************************************************************
//     * Prohodí pozice zadaných semaforů a nechá zkontrolovat,
//     * zda si semafory své pozice doopravdy vyměnily.
//     *
//     * @param s1 První semafor
//     * @param s2 Druhý semafor
//     */
//    private void pomProhoďPoziceSKontrolou(Semafor s1, Semafor s2)
//    {
//        Pozice p1 = s1.getPozice();
//        Pozice p2 = s2.getPozice();
//
//        System.out.println("Výchozí: " + p1 + " <--> " + p2);
//        pomPlynuleProhoďPozice(s1, s2);
//        System.out.println("Cílová:  " + s1.getPozice() +
//                              " <--> " + s2.getPozice() + "\n");
//
//        assertEquals(p1, s2.getPozice());
//        assertEquals(p2, s1.getPozice());
//    }
//
//%I-


//== INTERNÍ DATOVÉ TYPY =======================================================
//== VLASTNÍ TESTY =============================================================
//
//     /***************************************************************************
//      *
//      */
//     public void testXXX()
//     {
//     }


    public void testCyklus()
    {
        semafor0   .cyklus();
        semaforXY  .cyklus();
        semaforXYB .cyklus();
        semaforXYM .cyklus();
        semaforXYMB.cyklus();
    }


    public void testPlynuléPosuny()
    {
        Přesouvač p = new Přesouvač(10);
        p.přesunNa(100, 150, semafor0);
        p.přesunNa(150,   0, semaforXY);
        p.přesunNa(100,   0, semaforXYB);
        p.přesunNa(150, 150, semaforXYM);
        p.přesunNa(  0,   0, semaforXYMB);
    }

//%I+ <129
//
//    public void testPlynuleProhoďPozice()
//    {
//        pomPlynuleProhoďPozice(semaforXYMB, semafor0);
//        pomPlynuleProhoďPozice(semaforXYB,  semaforXYM);
//    }
//
//%I-

    public void testPoziceVelikost()
    {
//%I+ <129
//        pomPoziceVelikost(semafor0);
//        pomPoziceVelikost(semaforXY);
//        pomPoziceVelikost(semaforXYB);
//        pomPoziceVelikost(semaforXYM);
//        pomPoziceVelikost(semaforXYMB);
//%I-
//%X+ <129
        TestUtility.setPoziceModuly(new Pozice(50, 0), 25, 100);
        TestUtility.poziceVelikost(semafor0);
        TestUtility.poziceVelikost(semaforXY);
        TestUtility.poziceVelikost(semaforXYB);
        TestUtility.poziceVelikost(semaforXYM);
        TestUtility.poziceVelikost(semaforXYMB);
//%X-
    }
//%X+ <127


    public void testProhoďPoziceSKontrolou()
    {
//%X-
//%I+ >127 <129
//        pomProhoďPoziceSKontrolou(semafor0,   semaforXYMB);
//        pomProhoďPoziceSKontrolou(semaforXYB, semaforXYM);
//        pomProhoďPoziceSKontrolou(semaforXYM, semafor0);
//%I-
//%X+ <129
        TestUtility.prohoďPoziceSKontrolou(semafor0,   semaforXYMB);
        TestUtility.prohoďPoziceSKontrolou(semaforXYB, semaforXYM);
        TestUtility.prohoďPoziceSKontrolou(semaforXYM, semafor0);
//%X-
//%X+ <127
    }
//%X-
//%X+
     /** */
     public void testPřípravek() {}
//%X-
}

//%%-  ----- Začátek ignorovaného závěrečného textu -----
////////////////////////////////////////////////////////////////////////////////
//== TESTY A METODA MAIN =======================================================
//Není-li třída testovací, následující dvě metody se smažou


    /***************************************************************************
     * Třída, jejíž instance má na starosti úklid mezi jednotlivými testy,
     * který není možno zakomponovat do metody {@code tearDown()},
     * dokud nebudou studenti umět programovat.
     */
    private static class TearDown implements Run.ITD
    {
        /** {@inheritDoc} */
        @Override
        public void ukliď()
        {
//            Plátno.smažPlátno();
//            SprávcePlátna.getInstance().odstraňVše();
        }
    }


    /***************************************************************************
     * Testovací metoda.
     */
    public static void test()
    {
        Run.tests(SemaforTest.class,
                new TearDown(),
//                "testPřípravek",
//                "testCyklus",
                "testPoziceVelikost",
//                "testPlynuléPosuny",
//                "testPlynuleProhoďPozice",
                "testProhoďPoziceSKontrolou",
                "");
        System.exit(0);
    }
    /** @param args Parametry příkazového řádku - nepoužívané. */
    public static void main( String[] args )  {  test();  }
}
